import soTime from "@/js_sdk/fl-SOtime/SOtime.js"

let _this;
export default _this = {
    check: {
        /**
         * 判断小数位数是否超过了指定位数
         * 例: 1.111 返回 true 1.11 返回 false
         * @param val 小数
         * @param digits 位数
         * */
        isDecimalOutBounds(val, digits) {
            let s = val.toString();
            /* 不是小数或数字直接返回true */
            if (!this.isNumber(s) || !s.includes(".")) {
                return false
            }
            return s.length - 1 - s.indexOf('.') > digits
        },
        isNumber(val) {
            if (this.isNull(val)) {
                return false;
            }
            val = val.toString();
            let regPos = /^\d+(\.\d+)?$/;
            let regNeg = /^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/;
            return regPos.test(val) || regNeg.test(val);
        },
        isBankNumber(val) {
            let reg = /^([1-9]{1})(\d{14}|\d{18})$/;
            return reg.test(val)
        },
        isNull(v) {
            let result = typeof v === "undefined" || v === null || v === ''
            if (typeof v === "string") {
                result = v.trim() === ''
            }
            if (Array.isArray(v)) {
                result = v.length === 0
            }
            return result
        },
        /**
         * 传入时间戳 , 判断是否在当前时间之后
         * */
        isAfter(timestamp) {
            return new Date().getTime() > timestamp;
        },

        /**
         * 传入时间戳 , 判断是否在当前时间之前
         * */
        isBefore(timestamp) {
            return new Date().getTime() < timestamp;
        },

        /**
         * 数组中是否有元素为null
         * */
        arrItemIsNull(arr) {
            if (!Array.isArray(arr)) {
                console.log("arrItemIsNull 传入了非 Array 类型 转调 isNull param: ", arr)
                return this.isNull(arr);
            }
            return arr.some(e => this.isNull(e))
        },
        /**
         * 判断文件大小是否超标
         * 文件大小单位为 字节
         * @param arr 文件list
         * @param size 文件大小 单位 M
         * */
        fileSizeOutBounds(arr, size) {
            size *= 1000000
            return arr.some(e => {
                return e.size > size
            });
        }
    },

    style: {
        /**
         * @param v 值
         * @param index 下标
         * */
        time(v, index) {
            let result = ''
            switch (index) {
                case 3:
                    /* yyyy-MM-dd HH:mm */
                    result = soTime.time3(v);
                    break;
                case 6:
                    /* yyyy-MM-dd HH:mm:ss */
                    result = soTime.time6(v)
                    break;
                case 7:
                    /* 年-月-日 时:分:秒 */
                    result = soTime.time7(v)
                    break;
                case 8:
                    /* 年-月-日 时:分*/
                    result = soTime.time8(v)
                    break;
                case 9:
                    /* 年-月-日 */
                    result = soTime.time9(v)
                    break;
            }
            return result;
        }
    },
    html:{
        /**
         * 如果传入值为空 返回指定字符串
         * */
        isNullToStr(v,str = '丢失'){
            if (_this.check.isNull(v)) {
                return str
            }
            return v;
        },
        /**
         * 距离文本
         * */
        distanceText(km = 0){
            if (_this.check.isNull(km) || isNaN(km)){
                return '计算距离失败';
            }
            km = Number(km);
            let text = km > 1 ? km + " km" : km * 1000 + " m"
            if(km <= 0.1){
                text = '100 m 以内'
            }
            return '距离 ' + text;
        }
    }
    ,

    request: {
        /**
         * @param orderNum 我方系统订单号
         * @param type 订单类型
         * */
        createWxOrder(orderNum, type,axios) {
            return new Promise(function (resolve, reject) {
                uni.showLoading({
                    title: '创建订单中.....',
                    mask: true,
                })
                axios({
                    url: `wx/pay/createJsApiOrder`,
                    method: "post",
                    data: {orderNum: orderNum, type: type}
                }).then(res => {
                        if (res.code === 0) {
                            resolve(res)
                        }else {
                            reject(res)
                        }
                    }
                ).finally(() => {
                    uni.hideLoading();
                })
            })
        },
        /**
         * 微信支付请求
         * @param data 请求数据对象
         * @param success
         * @param fail
         * @param complete
         * */
        wxPayment(data,success=function (res) {},fail=function (res) {},complete=function () {}){
            uni.requestPayment({
                provider: 'wxpay',
                timeStamp: data.timeStamp,
                nonceStr: data.nonceStr,
                package: data.packageValue,
                signType: data.signType,
                paySign: data.paySign,
                success: function (res) {
                    success(res)
                },
                fail: function (res) {
                    fail(res)
                },
                complete: function (res) {
                    complete()
                }
            })
        }
    },
    copy(v) {
        return JSON.parse(JSON.stringify(v))
    },
    /**
     * 数组转字符串 ,
     * arr 数组
     * separator 元素分割符号
     * */
    arrToString(arr, separator) {
        if (typeof arr === "string") {
            return arr;
        }
        if (!Array.isArray(arr)) {
            throw new Error(' file : service.js | function : arrToString | msg : 非数组,非字符串 | value : ' + arr)
        }
        if (arr.length === 0) {
            return '';
        } else if (arr.length === 1) {
            return arr[0] + '';
        }
        let result = '';
        arr.forEach(e => {
            result += e + separator
        })
        return result.substring(0, result.length - 1)
    },
    /**
     * 预览图片
     * */
    previewImg(urls, index = 0) {
        uni.previewImage({
            current: index,
            urls: urls,
        })
    },
    /**
     * 用于获取响应中的多个参数 ,防止解析参数的过程中出错导致页面整体加载失败
     * task 需要执行的任务
     * errMsg 错误信息
     * errorFields 存储解析错误的字段数组
     * 执行任务
     * */
    executeTask(task = function () {
    }, errorFields = [], errMsg = '') {
        try {
            task();
        } catch (e) {
            console.log(" executeTask - err : ", e)
            errorFields.push(errMsg)
        }
    },

    copyText(text, field = '') {
        text = text.toString();
        uni.setClipboardData({
            data: text,
            success: function () {
                uni.showToast({
                    title: '复制 ' + field + ' 成功',
                    icon: 'none'
                })
            },
            fail: function () {
                uni.showToast({
                    title: '复制 ' + field + ' 失败',
                    icon: 'none'
                })
            }
        })
    },
    /**
     * 获取地址信息
     * v : 当前页面对象 , succeedEvent : 获取地区成功事件 格式 {ok:function(v,res){v.当前页面值或方法,res相应的值}}
     * */
    getLocation(v, succeedEvent) {
        let _this = this;
        let that = v
        uni.getSetting({
            success(res) {
                console.log('获取定位123', res);
                if (!res.authSetting['scope.userLocation']) {
                    console.log('获取定位456', res);
                    // 未授权
                    uni.authorize({
                        scope: 'scope.userLocation',
                        success() { //1.1 允许授权
                            // uni.getLocation()
                            wx.getSystemInfo({
                                success(res) {
                                    that.isopendingwei = res.locationEnabled;
                                    if (that.isopendingwei == false) {
                                        uni.showToast({
                                            title: '请先开启手机GPS定位,然后重新刷新',
                                            icon: "none",
                                            duration: 3000,
                                        })
                                        return
                                    }
                                }
                            })
                            if (!that.isopendingwei) {
                                uni.showToast({
                                    title: '请先开启手机GPS定位,然后重新刷新',
                                    icon: "none",
                                    duration: 3000,
                                })
                                return
                            }
                            console.log('获取定位789', res);
                            uni.getLocation({
                                type: 'wgs84',
                                geocode: true,
                                success: function (res) {
                                    console.log('获取定位1011', res);
                                    succeedEvent["ok"](v, res);
                                },
                                fail: (err) => {
                                    console.log("err", err)
                                }
                            });
                        },
                        fail() { //1.2 拒绝授权
                            uni.showModal({
                                showCancel: false,
                                title: "温馨提示",
                                content: "微信小程序需要您的位置信息，请前往开启",
                                confirmColor: "#E02020",
                                success: (res) => {
                                    if (res.confirm) {
                                        uni.openSetting({
                                            success: (res) => {
                                                uni.redirectTo({
                                                    url: v.__route__
                                                })
                                            },
                                        })
                                    }
                                }
                            })
                        }

                    })
                } else {
                    uni.getLocation({
                        type: 'wgs84',
                        geocode: true,
                        success: function (res) {
                            succeedEvent["ok"](v, res);
                        }
                    });
                }
            },

        });
    },

    handleMapLocation(_t,latitude,longitude,address='',success=function (_t,res) {}) {
        console.log('进入导航')
        latitude = Number(latitude);
        longitude = Number(longitude);
        // 获取定位信息
        uni.getLocation({
            type: 'wgs84', //返回可以用于uni.openLocation的经纬度
            // 用户允许获取定位
            success: function (res) {
                console.log(res, '经纬度===>', latitude, longitude)
                if (res.errMsg === "getLocation:ok") {
                    uni.openLocation({
                        // 传入你要去的纬度
                        latitude: latitude,
                        // 传入你要去的经度
                        longitude: longitude,
                        // 传入你要去的地址信息 不填则为空
                        address: address,
                        // 缩放大小
                        scale: 10,
                        success: function () {
                            success(_t,res);
                        }
                    });
                }
            },
            // 用户拒绝获取定位后 再次点击触发
            fail: function (res) {
                console.log(res)
                if (res.errMsg === "getLocation:fail auth deny") {
                    uni.showModal({
                        showCancel: false,
                        title: "温馨提示",
                        content: "微信小程序需要您的位置信息，请前往开启",
                        confirmColor: "#E02020",
                        success: (res) => {
                            if (res.confirm) {
                                uni.openSetting({
                                    success: (res) => {
                                        uni.redirectTo({
                                            url: _t.__route__
                                        })
                                    },
                                })
                            }
                        }
                    })
                }
            }
        });
    }
}